<template>
  <a-tree
    v-model:expandedKeys="expandedKeys"
    :field-names="fieldNames"
    :checkedKeys="checkedKeys"
    :autoExpandParent="true"
    :treeData="treeData"
    checkStrictly
    checkable
    :disabled="false"
    @check="handleCheck"
  >
    <template #title="{ checked, agentName, agentNo, data }">
      <a-space>
        <span>{{ agentName }}</span>
        <div v-if="treeData[0].agentNo === agentNo" style="display: flex;gap: 10px;">
          <!-- <div style="display: flex;align-items: center;">
            <span style="flex-shrink: 0;margin-right: 5px;">未发放数量：</span>
            <div style="padding: 0 6px;background: #f5f5f5;">{{ totalNum }}</div>
          </div> -->
          <div style="display: flex;align-items: center;">
            <span style="flex-shrink: 0;margin-right: 5px;">可配置数量：</span>
            <div style="padding: 0 6px;background: #f5f5f5;">{{ (totalNum - configuredNum) < 0 ? 0 : (totalNum - configuredNum) }}</div>
          </div>
        </div>
        
        <div v-else-if="checked">
          <a-input-number
            :min="0"
            :precision="0"
            :value="data.num"
            :controls="false"
            size="small"
            @blur="($event) => handleBlur(data,$event)"
          />
          <span style="margin-left: 10px;">张</span>
        </div>
        <div v-if="checked&&data.numConsume!==undefined">
          <span style="margin-left: 10px;">已派发</span>
          {{ data.numConsume }}
          <span style="margin-left: 10px;">张</span>
        </div>
      </a-space>
    </template>
  </a-tree>
</template>

<script setup lang="ts">
import { getCurrentInstance, defineEmits, computed, defineExpose,ref, onMounted } from 'vue'

const { $infoBox } = getCurrentInstance()!.appContext.config.globalProperties

const props = defineProps({
  treeData: {
    type: Array,
    default: () => []
  },
  // 总发放数量
  totalNum: {
    type: Number,
    default: 0
  },
  checkStrictly1:{
    type:Boolean,
    
  },
  // 选中的机构
  checkedKeys: {
    type: Array,
    default: () => []
  },
  // 是否禁用
  disabled: {
    type: Boolean,
    default: false
  }
})


console.log(props.checkStrictly1,'选中的节点是那个')

const emits = defineEmits(['treeChange','update:checkedKeys'])

const fieldNames = {
  children: 'children',
  title: 'agentName',
  key: 'agentNo'
}

// 选中的默认展开
const expandedKeys= ref([])

onMounted(() => {
  expandedKeys.value = JSON.parse(JSON.stringify(props.checkedKeys))
})

/**
 * 获取所有子节点的 key
 */
 function getAllChildKeys(node) {
  let keys = []
  if (node.children) {
    node.children.forEach(child => {
      keys.push(child.agentNo)
      if (child.children) {
        keys = keys.concat(getAllChildKeys(child))
      }
    })
  }
  return keys
}

/**
 * 递归将子节点的 num 设置为 0
 */
 function resetChildNum(node) {
  // 将当前节点的 num 设置为 0
  node.num = 0
  emits('treeChange', node.agentNo, 0) // 通知父组件更新

  if (node.children) {
    node.children.forEach(child => {
      child.num = 0 // 将子节点的 num 设置为 0
      emits('treeChange', child.agentNo, 0) // 通知父组件更新
      if (child.children) {
        resetChildNum(child) // 递归处理子节点
      }
    })
  }
}

/**
* 处理机构选中事件
*/
function handleCheck(checkedKeys, {checked, checkedNodes, node, event}) {

  // console.log(checkedKeys?.checked,checked,'节点节点')
  // if(checkedKeys?.checked){
  //   emits('update:checkedKeys',checkedKeys.checked)
  // }
  // if (checked) {
  //   console.log('选中所有子节点')
  //   // 选中父节点时，递归选中所有子节点
  //   const allChildKeys = getAllChildKeys(node)

  //   const newCheckedKeys = [...new Set([...checkedKeys.checked, ...allChildKeys])]
  //   console.log(allChildKeys,newCheckedKeys,456456)
  //   emits('update:checkedKeys', newCheckedKeys)
  // } else {
  //   console.log('取消所有子节点')
  //   // 取消选中父节点时，递归取消选中所有子节点
  //   const allChildKeys = getAllChildKeys(node)
  //   const newCheckedKeys = checkedKeys?.checked.filter(key => !allChildKeys.includes(key))
  //   emits('update:checkedKeys', newCheckedKeys)
  // }

  if(props.checkStrictly1){
    let newCheckedKeys = [...checkedKeys.checked]

if (checked) {
  // 选中父节点时，递归选中所有子节点
  const childKeys = getAllChildKeys(node)
  newCheckedKeys = [...new Set([...newCheckedKeys, ...childKeys])]
  resetChildNum(node) // 递归将子节点的 num 设置为 0
} else {
  // 取消选中父节点时，递归取消选中所有子节点，并将子节点的 num 设置为 0
  const childKeys = getAllChildKeys(node)
  newCheckedKeys = newCheckedKeys.filter(key => !childKeys.includes(key))
  
}

// 更新 checkedKeys
emits('update:checkedKeys', newCheckedKeys)
  }else{
      if(checkedKeys?.checked){
    emits('update:checkedKeys',checkedKeys.checked)
  }
  }


  // if(checkedKeys?.checked){
  //   emits('update:checkedKeys',checkedKeys.checked)
  // }
  // 更新取消勾选的机构数量
  if(!checked){
    // 判断当前取消勾选的节点的子节点是否存在已配置数量
    // if(node.children){
    //   let nums = 0
    //   node.children.forEach(child => {
    //     if(child.num){
    //       nums += child.num
    //     }
    //   })
    //   emits('treeChange',node.agentNo,nums === 0 ? null : nums)
    // }

    // // // 除了更新自身的数量之外 还需要更新 父节点的数量
    // if(node.level - props.treeData[0].level > 1){
    //   const parentNode = getParentNode(props.treeData,node.pid)
    //   // 更新父节点数量
    //   if(parentNode.children){
    //     let nums = 0
    //     parentNode.children.forEach(child => {
    //       if(child.num && child.agentNo!== node.agentNo){
    //         nums += child.num
    //       }
    //     })
    //     emits('treeChange',node.pid,nums === 0 ? null : nums)
    //   }
    // }

    let nums = 0
    if(node.children){
      node.children.forEach(child => {
        if(child.num){
          nums += child.num
        }
      })
    }
    handleBlur(node,{target:{value:nums === 0 ? null : nums}})
  }
}

/**
 * 数量配置事件
 */
function handleBlur(data,e) {
  // 确定最终要改的数量
  let lastNum = Number(e.target.value)
  if(data.minAwardNum && (lastNum < data.minAwardNum)){
    lastNum = data.minAwardNum
  }
  if(lastNum){
    emits('treeChange',data.agentNo,lastNum)
  }else{
    emits('treeChange',data.agentNo,null)
  }
  // 判断当前节点是几级节点 如果是三级节点或者四级节点 则需要更新父节点的数量
  if((data.level !== 2 && props.treeData[0].level === 1) || (data.level === 4 && props.treeData[0].level === 2)){
    setParentNum(data)  // 子数量赋值给父数量
  }
  checkNum()
}

/**
 * 已配置数量
 */
const configuredNum = computed(() => {
  let num = 0
  if(props.treeData[0].children){
    props.treeData[0].children.forEach(item => {
      if(item.num){
        num += item.num
      }
    })
  }else{
    num = props.treeData[0].num
  }
  return num
})

/**
 * 检测分配的数量是否合法
 */
function checkNum() {
  // 是否超过总数量
  if(props.totalNum - configuredNum.value < 0){
    $infoBox.message.warn('分配的数量超过总数量，请重新分配！')
    return false
  }
  // 子级数量是否超出父级数量
  if(!checkChildNum(props.treeData[0].children)){
    return false
  }
  return true
}
/**
 * 校验子节点数量是否超出父节点数量
 */
function checkChildNum(rootNode) {
  for(let parent of rootNode){
    const parentNum = parent.num
    let childNum = 0
    if(parent.children){
      for(let child of parent.children){
        if(child.num){
          childNum += child.num
        }
      }
    }
    if(childNum > parentNum){
      $infoBox.message.warn(`下级网点分配的数量大于上级网点可分配数量，请重新分配！`)
      return false
    }else if(parent.children){
      checkChildNum(parent.children)
    }
  }
  return true
}
/**
 * 子数量赋值给父数量
 */
function setParentNum(currentNode) {
  const parentNode = getParentNode(props.treeData,currentNode.pid)
  // if(!parentNode.hasOwnProperty('num')){
  // if(!isChecked(parentNode.agentNo)){
  //   let parentNum = 0
  //   parentNode.children.forEach(item => {
  //     if(item.num){
  //       parentNum += item.num
  //     }
  //   })
  //   emits('treeChange',parentNode.agentNo,parentNum === 0 ? null : parentNum)
  // }
  let parentNum = 0
  parentNode.children.forEach(item => {
    if(item.num){
      parentNum += item.num
    }
  })
  let lastParentNum = parentNum
  if(parentNode.minAwardNum && (lastParentNum < parentNode.minAwardNum)){
    lastParentNum = parentNode.minAwardNum
  }
  emits('treeChange',parentNode.agentNo,lastParentNum === 0 ? null : lastParentNum)
  if(currentNode.level === 4 && props.treeData[0].level === 1){ // 多级父节点赋值
    setParentNum(parentNode)
  }
}
/**
 * 判断节点是否选中
 */
function isChecked(agentNo) {
  return props.checkedKeys.includes(agentNo)
}

/**
 * 递归查询父节点 nodeData 根节点 agentNo 父节点agentNo
 */
function getParentNode(nodeData, agentNo) {
  for (let item of nodeData) {
    if (item.agentNo === agentNo) {
      return item // 找到节点，立即返回
    } else if (item.children) {
      const foundNode = getParentNode(item.children, agentNo)
      if (foundNode) {
        return foundNode // 找到子节点的父节点，立即返回
      }
    }
  }
  return null // 未找到节点
}
/**
 * 暴露接口
 */
defineExpose({ checkNum })

</script>

<style label="less" scoped>
</style>